/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package mrp.persistencia.controller;

import java.io.Serializable;
import javax.persistence.Query;
import javax.persistence.EntityNotFoundException;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;
import mrp.persistencia.entity.Modelocalzado;
import java.util.ArrayList;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.transaction.UserTransaction;
import mrp.beans.util.EntityManagerUtil;
import mrp.persistencia.controller.exceptions.IllegalOrphanException;
import mrp.persistencia.controller.exceptions.NonexistentEntityException;
import mrp.persistencia.controller.exceptions.PreexistingEntityException;
import mrp.persistencia.controller.exceptions.RollbackFailureException;
import mrp.persistencia.entity.Horma;

/**
 *
 * @author root
 */
public class HormaJpaController implements Serializable {

    
    public HormaJpaController() {
        
        this.emf = EntityManagerUtil.getEntityManagerFactory();
    }

    private EntityManagerFactory emf = null;

    public EntityManager getEntityManager() {
        return emf.createEntityManager();
    }

    public boolean create(Horma horma) throws PreexistingEntityException, Exception {
        boolean creo=false;
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            em.persist(horma);
            em.getTransaction().commit();
            creo=true;
        } catch (Exception ex) {
            if (findHorma(horma.getCodhorma()) != null) {
                throw new PreexistingEntityException("Horma " + horma + " ya existe en el sistema.", ex);
            }            
            throw ex;
        } finally {
            if (em != null) {
                em.close();
                
            }
        }
        return creo;
    }

    public void edit(Horma horma) throws NonexistentEntityException, Exception {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            horma = em.merge(horma);
            em.getTransaction().commit();
        } catch (Exception ex) {
            String msg = ex.getLocalizedMessage();
            if (msg == null || msg.length() == 0) {
                String id = horma.getCodhorma();
                if (findHorma(id) == null) {
                    throw new NonexistentEntityException("La Horma con código " + id + " no existe en el sistema.");
                }
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void destroy(String id) throws NonexistentEntityException {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Horma horma;
            try {
                horma = em.getReference(Horma.class, id);
                horma.getCodhorma();
            } catch (EntityNotFoundException enfe) {
                throw new NonexistentEntityException("La Horma con código " + id + " no existe en el sistema.", enfe);
            }
            em.remove(horma);
            em.getTransaction().commit();
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public List<Horma> findHormaEntities() {
        return findHormaEntities(true, -1, -1);
    }

    public List<Horma> findHormaEntities(int maxResults, int firstResult) {
        return findHormaEntities(false, maxResults, firstResult);
    }

    private List<Horma> findHormaEntities(boolean all, int maxResults, int firstResult) {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            cq.select(cq.from(Horma.class));
            Query q = em.createQuery(cq);
            if (!all) {
                q.setMaxResults(maxResults);
                q.setFirstResult(firstResult);
            }
            return q.getResultList();
        } finally {
            em.close();
        }
    }

    public Horma findHorma(String id) {
        EntityManager em = getEntityManager();
        try {
            return em.find(Horma.class, id);
        } finally {
            em.close();
        }
    }

    public int getHormaCount() {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            Root<Horma> rt = cq.from(Horma.class);
            cq.select(em.getCriteriaBuilder().count(rt));
            Query q = em.createQuery(cq);
            return ((Long) q.getSingleResult()).intValue();
        } finally {
            em.close();
        }
    }
    public List<Horma> findHormaWhere(String condicion) {
        EntityManager em = null;
        em = getEntityManager();
        try {
            Query q = em.createQuery("SELECT o FROM Horma o "+condicion+" order by o.codhorma");
            List l = q.getResultList();            
            return l;
        } 
        catch(Exception e)
        {e.printStackTrace();}
        finally {
            em.close();
        }
        return null;
    }
    
    public List<Horma> findHormaOrderByAll() {
        return findHormaOrderBy(true, -1, -1);
    }

    public List<Horma> findHormaOrderByLazy(int maxResults, int firstResult) {
        return findHormaOrderBy(false, maxResults, firstResult);
    }
     private List<Horma> findHormaOrderBy(boolean all, int maxResults, int firstResult) {
        EntityManager em = null;
        em = getEntityManager();
        try {
            Query q = em.createQuery("SELECT o FROM Horma o order by o.codhorma");
             if (!all) {
                q.setMaxResults(maxResults);
                q.setFirstResult(firstResult);
            }           
            return q.getResultList();
        } 
        catch(Exception e)
        {e.printStackTrace();}
        finally {
            em.close();
        }
        return null;
    }
    
//    public HormaJpaController(UserTransaction utx, EntityManagerFactory emf) {
//        this.utx = utx;
//        this.emf = emf;
//    }
//    private UserTransaction utx = null;
//    private EntityManagerFactory emf = null;
//
//    public EntityManager getEntityManager() {
//        return emf.createEntityManager();
//    }
//
//    public void create(Horma horma) throws PreexistingEntityException, RollbackFailureException, Exception {
//        if (horma.getModelocalzadoList() == null) {
//            horma.setModelocalzadoList(new ArrayList<Modelocalzado>());
//        }
//        EntityManager em = null;
//        try {
//            utx.begin();
//            em = getEntityManager();
//            List<Modelocalzado> attachedModelocalzadoList = new ArrayList<Modelocalzado>();
//            for (Modelocalzado modelocalzadoListModelocalzadoToAttach : horma.getModelocalzadoList()) {
//                modelocalzadoListModelocalzadoToAttach = em.getReference(modelocalzadoListModelocalzadoToAttach.getClass(), modelocalzadoListModelocalzadoToAttach.getCodestructuramateria());
//                attachedModelocalzadoList.add(modelocalzadoListModelocalzadoToAttach);
//            }
//            horma.setModelocalzadoList(attachedModelocalzadoList);
//            em.persist(horma);
//            for (Modelocalzado modelocalzadoListModelocalzado : horma.getModelocalzadoList()) {
//                Horma oldHormaOfModelocalzadoListModelocalzado = modelocalzadoListModelocalzado.getHorma();
//                modelocalzadoListModelocalzado.setHorma(horma);
//                modelocalzadoListModelocalzado = em.merge(modelocalzadoListModelocalzado);
//                if (oldHormaOfModelocalzadoListModelocalzado != null) {
//                    oldHormaOfModelocalzadoListModelocalzado.getModelocalzadoList().remove(modelocalzadoListModelocalzado);
//                    oldHormaOfModelocalzadoListModelocalzado = em.merge(oldHormaOfModelocalzadoListModelocalzado);
//                }
//            }
//            utx.commit();
//        } catch (Exception ex) {
//            try {
//                utx.rollback();
//            } catch (Exception re) {
//                throw new RollbackFailureException("An error occurred attempting to roll back the transaction.", re);
//            }
//            if (findHorma(horma.getCodhorma()) != null) {
//                throw new PreexistingEntityException("Horma " + horma + " already exists.", ex);
//            }
//            throw ex;
//        } finally {
//            if (em != null) {
//                em.close();
//            }
//        }
//    }
//
//    public void edit(Horma horma) throws IllegalOrphanException, NonexistentEntityException, RollbackFailureException, Exception {
//        EntityManager em = null;
//        try {
//            utx.begin();
//            em = getEntityManager();
//            Horma persistentHorma = em.find(Horma.class, horma.getCodhorma());
//            List<Modelocalzado> modelocalzadoListOld = persistentHorma.getModelocalzadoList();
//            List<Modelocalzado> modelocalzadoListNew = horma.getModelocalzadoList();
//            List<String> illegalOrphanMessages = null;
//            for (Modelocalzado modelocalzadoListOldModelocalzado : modelocalzadoListOld) {
//                if (!modelocalzadoListNew.contains(modelocalzadoListOldModelocalzado)) {
//                    if (illegalOrphanMessages == null) {
//                        illegalOrphanMessages = new ArrayList<String>();
//                    }
//                    illegalOrphanMessages.add("You must retain Modelocalzado " + modelocalzadoListOldModelocalzado + " since its horma field is not nullable.");
//                }
//            }
//            if (illegalOrphanMessages != null) {
//                throw new IllegalOrphanException(illegalOrphanMessages);
//            }
//            List<Modelocalzado> attachedModelocalzadoListNew = new ArrayList<Modelocalzado>();
//            for (Modelocalzado modelocalzadoListNewModelocalzadoToAttach : modelocalzadoListNew) {
//                modelocalzadoListNewModelocalzadoToAttach = em.getReference(modelocalzadoListNewModelocalzadoToAttach.getClass(), modelocalzadoListNewModelocalzadoToAttach.getCodestructuramateria());
//                attachedModelocalzadoListNew.add(modelocalzadoListNewModelocalzadoToAttach);
//            }
//            modelocalzadoListNew = attachedModelocalzadoListNew;
//            horma.setModelocalzadoList(modelocalzadoListNew);
//            horma = em.merge(horma);
//            for (Modelocalzado modelocalzadoListNewModelocalzado : modelocalzadoListNew) {
//                if (!modelocalzadoListOld.contains(modelocalzadoListNewModelocalzado)) {
//                    Horma oldHormaOfModelocalzadoListNewModelocalzado = modelocalzadoListNewModelocalzado.getHorma();
//                    modelocalzadoListNewModelocalzado.setHorma(horma);
//                    modelocalzadoListNewModelocalzado = em.merge(modelocalzadoListNewModelocalzado);
//                    if (oldHormaOfModelocalzadoListNewModelocalzado != null && !oldHormaOfModelocalzadoListNewModelocalzado.equals(horma)) {
//                        oldHormaOfModelocalzadoListNewModelocalzado.getModelocalzadoList().remove(modelocalzadoListNewModelocalzado);
//                        oldHormaOfModelocalzadoListNewModelocalzado = em.merge(oldHormaOfModelocalzadoListNewModelocalzado);
//                    }
//                }
//            }
//            utx.commit();
//        } catch (Exception ex) {
//            try {
//                utx.rollback();
//            } catch (Exception re) {
//                throw new RollbackFailureException("An error occurred attempting to roll back the transaction.", re);
//            }
//            String msg = ex.getLocalizedMessage();
//            if (msg == null || msg.length() == 0) {
//                String id = horma.getCodhorma();
//                if (findHorma(id) == null) {
//                    throw new NonexistentEntityException("The horma with id " + id + " no longer exists.");
//                }
//            }
//            throw ex;
//        } finally {
//            if (em != null) {
//                em.close();
//            }
//        }
//    }
//
//    public void destroy(String id) throws IllegalOrphanException, NonexistentEntityException, RollbackFailureException, Exception {
//        EntityManager em = null;
//        try {
//            utx.begin();
//            em = getEntityManager();
//            Horma horma;
//            try {
//                horma = em.getReference(Horma.class, id);
//                horma.getCodhorma();
//            } catch (EntityNotFoundException enfe) {
//                throw new NonexistentEntityException("The horma with id " + id + " no longer exists.", enfe);
//            }
//            List<String> illegalOrphanMessages = null;
//            List<Modelocalzado> modelocalzadoListOrphanCheck = horma.getModelocalzadoList();
//            for (Modelocalzado modelocalzadoListOrphanCheckModelocalzado : modelocalzadoListOrphanCheck) {
//                if (illegalOrphanMessages == null) {
//                    illegalOrphanMessages = new ArrayList<String>();
//                }
//                illegalOrphanMessages.add("This Horma (" + horma + ") cannot be destroyed since the Modelocalzado " + modelocalzadoListOrphanCheckModelocalzado + " in its modelocalzadoList field has a non-nullable horma field.");
//            }
//            if (illegalOrphanMessages != null) {
//                throw new IllegalOrphanException(illegalOrphanMessages);
//            }
//            em.remove(horma);
//            utx.commit();
//        } catch (Exception ex) {
//            try {
//                utx.rollback();
//            } catch (Exception re) {
//                throw new RollbackFailureException("An error occurred attempting to roll back the transaction.", re);
//            }
//            throw ex;
//        } finally {
//            if (em != null) {
//                em.close();
//            }
//        }
//    }
//
//    public List<Horma> findHormaEntities() {
//        return findHormaEntities(true, -1, -1);
//    }
//
//    public List<Horma> findHormaEntities(int maxResults, int firstResult) {
//        return findHormaEntities(false, maxResults, firstResult);
//    }
//
//    private List<Horma> findHormaEntities(boolean all, int maxResults, int firstResult) {
//        EntityManager em = getEntityManager();
//        try {
//            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
//            cq.select(cq.from(Horma.class));
//            Query q = em.createQuery(cq);
//            if (!all) {
//                q.setMaxResults(maxResults);
//                q.setFirstResult(firstResult);
//            }
//            return q.getResultList();
//        } finally {
//            em.close();
//        }
//    }
//
//    public Horma findHorma(String id) {
//        EntityManager em = getEntityManager();
//        try {
//            return em.find(Horma.class, id);
//        } finally {
//            em.close();
//        }
//    }
//
//    public int getHormaCount() {
//        EntityManager em = getEntityManager();
//        try {
//            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
//            Root<Horma> rt = cq.from(Horma.class);
//            cq.select(em.getCriteriaBuilder().count(rt));
//            Query q = em.createQuery(cq);
//            return ((Long) q.getSingleResult()).intValue();
//        } finally {
//            em.close();
//        }
//    }
    
}
